#!/bin/bash
#####################################################################
# 功能：Redis 交互管理脚本
# 作者：wurenlong & Copilot Pro
# 版本：1.0.0
#####################################################################
# 错误处理和环境设置
set -e  # 遇到错误立即退出
export LANG="zh_CN.UTF-8"  # 设置中文环境
trap 'echo -e "${RED}错误：程序异常退出，请检查日志${NC}"; exit 1' ERR  # 错误捕获

# 颜色定义 - 添加颜色检测支持
setup_colors() {
    # 检查终端是否支持颜色
    TERM_COLORS=$(tput colors 2>/dev/null || echo 0)
    
    # 检查TERM环境变量
    if [[ "$TERM" == "dumb" || $TERM_COLORS -eq 0 ]]; then
        # 终端不支持颜色，使用空字符串
        RED=''
        GREEN=''
        YELLOW=''
        BLUE=''
        CYAN=''
        NC=''
    elif [[ -t 1 ]]; then
        # 标准输出是终端，使用颜色
        RED='\033[0;31m'
        GREEN='\033[0;32m'
        YELLOW='\033[0;33m'
        BLUE='\033[0;34m'
        CYAN='\033[0;36m'
        NC='\033[0m' # No Color
    else
        # 标准输出不是终端，使用空字符串
        RED=''
        GREEN=''
        YELLOW=''
        BLUE=''
        CYAN=''
        NC=''
    fi
    
    # 导出变量以便在函数中使用
    export RED GREEN YELLOW BLUE CYAN NC
}

# 配置变量
REDIS_HOST="127.0.0.1"
REDIS_PORT=8181
REDIS_AUTH="QWE_890_ujm"
REDIS_CONFIG="/usr/local/redis-5.0.9/etc/redis.conf"
REDIS_LOG="/data/logs/redis/redis.log"
REDIS_DATA_DIR="/data/redis"
REDIS_BACKUP_DIR="/data/redis/backups"
# Redis程序路径
REDIS_SERVER="/usr/local/redis-5.0.9/bin/redis-server"
REDIS_CLI="/usr/local/redis-5.0.9/bin/redis-cli"

# 初始化颜色
setup_colors

# 检查是否安装了Redis
check_redis_installation() {
    if ! [ -x "$REDIS_CLI" ]; then
        echo -e "${RED}错误: Redis 客户端未安装或路径不正确!${NC}"
        echo "请检查Redis安装路径: $REDIS_CLI"
        exit 1
    fi
}

# 验证Redis连接（增强的重试机制和错误诊断）
verify_redis_connection() {
    local retries=3
    local retry_count=0
    local delay=1
    local connected=false
    local connection_error=""
    
    echo -e "${BLUE}正在连接Redis服务器 $REDIS_HOST:$REDIS_PORT...${NC}"
    
    while [ $retry_count -lt $retries ] && [ "$connected" != "true" ]; do
        # 测试端口是否打开
        if ! timeout 3 bash -c "</dev/tcp/$REDIS_HOST/$REDIS_PORT" 2>/dev/null; then
            connection_error="端口连接失败"
            retry_count=$((retry_count+1))
            if [ $retry_count -lt $retries ]; then
                echo -e "${YELLOW}连接失败(端口不可达)，尝试重新连接 (${retry_count}/${retries})...${NC}"
                sleep $delay
                delay=$((delay*2))
            fi
            continue
        fi
        
        # 尝试与Redis通信 - 改进的方法
        local auth_result="FAIL"
        local ping_result="FAIL"
        
        # 创建临时文件保存命令输出
        local tmp_auth_output=$(mktemp)
        local tmp_ping_output=$(mktemp)
        
        # 使用单一连接执行AUTH和PING命令
        if [[ -n "$REDIS_AUTH" ]]; then
            echo -e "AUTH $REDIS_AUTH\r\nPING\r\nQUIT" | $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT > $tmp_auth_output 2>&1
            
            # 检查输出中是否有OK和PONG
            if grep -q "OK" $tmp_auth_output && grep -q "PONG" $tmp_auth_output; then
                connected=true
                break
            else
                # 分别测试AUTH和PING，便于诊断
                echo -n "AUTH $REDIS_AUTH" | $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT > $tmp_auth_output 2>&1
                if grep -q "OK" $tmp_auth_output; then
                    auth_result="OK"
                fi
                
                # 如果AUTH成功，再测试PING
                if [ "$auth_result" = "OK" ]; then
                    # 使用-a参数直接传递密码进行PING测试
                    $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT -a "$REDIS_AUTH" PING > $tmp_ping_output 2>/dev/null
                    if grep -q "PONG" $tmp_ping_output; then
                        ping_result="OK"
                        connected=true
                        break
                    fi
                    
                    # 如果前一种方法失败，再尝试另一种方式
                    echo -e "AUTH $REDIS_AUTH\r\nPING" | $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT > $tmp_ping_output 2>&1
                    if grep -q "PONG" $tmp_ping_output; then
                        ping_result="OK"
                        connected=true
                        break
                    fi
                    
                    # 记录错误详情
                    connection_error="AUTH成功但PING失败，可能存在保护模式或权限问题"
                else
                    connection_error="AUTH失败: 密码可能不正确"
                fi
            fi
        else
            # 无密码模式
            echo "PING" | $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT > $tmp_ping_output 2>&1
            if grep -q "PONG" $tmp_ping_output; then
                connected=true
                break
            else
                # 检查是否需要密码
                if grep -q "NOAUTH" $tmp_ping_output || grep -q "Authentication required" $tmp_ping_output; then
                    connection_error="Redis需要密码认证，但未提供密码"
                else
                    connection_error="PING失败，可能存在其他连接问题"
                fi
            fi
        fi
        
        # 清理临时文件
        rm -f $tmp_auth_output $tmp_ping_output
        
        retry_count=$((retry_count+1))
        if [ $retry_count -lt $retries ]; then
            echo -e "${YELLOW}连接失败(${connection_error})，尝试重新连接 (${retry_count}/${retries})...${NC}"
            sleep $delay
            delay=$((delay*2))
        fi
    done
    
    if [ "$connected" = "true" ]; then
        echo -e "${GREEN}成功连接到Redis服务器${NC}"
        return 0
    else
        echo -e "${RED}错误: 无法连接到Redis服务器 $REDIS_HOST:$REDIS_PORT (${connection_error})${NC}"
        diagnose_connection_issue
        return 1
    fi
}

# 诊断连接问题
diagnose_connection_issue() {
    echo -e "${YELLOW}正在诊断连接问题...${NC}"
    
    # 检查网络连通性
    if ping -c 1 $REDIS_HOST >/dev/null 2>&1; then
        echo -e "${GREEN}网络连接正常: 可以ping通 $REDIS_HOST${NC}"
    else
        echo -e "${RED}网络连接问题: 无法ping通 $REDIS_HOST${NC}"
    fi
    
    # 检查端口是否开放
    if command -v nc &>/dev/null; then
        if nc -z -w2 $REDIS_HOST $REDIS_PORT >/dev/null 2>&1; then
            echo -e "${GREEN}端口 $REDIS_PORT 已开放${NC}"
        else
            echo -e "${RED}端口 $REDIS_PORT 未开放或被防火墙阻止${NC}"
        fi
    else
        if timeout 2 bash -c "< /dev/tcp/$REDIS_HOST/$REDIS_PORT" 2>/dev/null; then
            echo -e "${GREEN}端口 $REDIS_PORT 已开放${NC}"
        else
            echo -e "${RED}端口 $REDIS_PORT 未开放或被防火墙阻止${NC}"
        fi
    fi
    
    # 显示所有Redis进程
    echo -e "${YELLOW}系统中的Redis进程:${NC}"
    ps -ef | grep "redis-server" | grep -v grep
    
    # 检查Redis进程
    if get_redis_process_status; then
        echo -e "${GREEN}Redis服务进程正在运行${NC}"
        
        # 尝试直接使用端口号检查
        local port_check=$(ps -ef | grep "redis-server.*:$REDIS_PORT" | grep -v grep)
        if [ -n "$port_check" ]; then
            echo -e "${GREEN}确认有Redis进程监听在端口 $REDIS_PORT${NC}"
            echo "$port_check"
        else
            echo -e "${YELLOW}警告: 未找到监听端口 $REDIS_PORT 的Redis进程${NC}"
            echo -e "${YELLOW}系统中运行的Redis可能使用了不同的端口${NC}"
            
            # 尝试找出Redis正在使用的端口
            local possible_ports=$(ps -ef | grep "redis-server" | grep -v grep | grep -o ":[0-9]\+" | cut -d: -f2)
            if [ -n "$possible_ports" ]; then
                echo -e "${YELLOW}检测到可能的Redis端口:${NC}"
                echo "$possible_ports"
                echo -e "${YELLOW}建议使用选项8更新连接设置以匹配这些端口之一${NC}"
            fi
        fi
    else
        echo -e "${RED}Redis服务进程未运行，请尝试启动服务${NC}"
    fi
    
    # 检查配置文件是否存在
    if [ -f "$REDIS_CONFIG" ]; then
        echo -e "${GREEN}配置文件存在: $REDIS_CONFIG${NC}"
        
        # 检查配置文件中的端口设置
        local conf_port=$(grep "^port" $REDIS_CONFIG | awk '{print $2}')
        if [ -n "$conf_port" ]; then
            if [ "$conf_port" != "$REDIS_PORT" ]; then
                echo -e "${RED}警告: 配置文件中的端口 ($conf_port) 与当前设置 ($REDIS_PORT) 不匹配${NC}"
                echo -e "${YELLOW}建议将连接端口更改为 $conf_port${NC}"
            else
                echo -e "${GREEN}配置文件端口设置正确: $conf_port${NC}"
            fi
        fi
        
        # 检查配置文件中的绑定地址
        local bind_addr=$(grep "^bind" $REDIS_CONFIG | awk '{print $2}')
        if [ -n "$bind_addr" ]; then
            if [ "$bind_addr" != "0.0.0.0" ] && [ "$bind_addr" != "$REDIS_HOST" ] && [ "$bind_addr" != "127.0.0.1" ]; then
                echo -e "${RED}警告: Redis可能绑定在 $bind_addr，而不是 $REDIS_HOST${NC}"
            else
                echo -e "${GREEN}绑定地址设置正确: $bind_addr${NC}"
            fi
        fi
        
        # 检查密码设置
        if grep -q "^requirepass" $REDIS_CONFIG; then
            local conf_pwd=$(grep "^requirepass" $REDIS_CONFIG | cut -d' ' -f2)
            local pwd_preview="${conf_pwd:0:3}***${conf_pwd: -3}"
            if [ -z "$REDIS_AUTH" ]; then
                echo -e "${RED}警告: Redis配置了密码，但当前连接未设置密码${NC}"
            elif [ "$conf_pwd" != "$REDIS_AUTH" ]; then
                echo -e "${RED}警告: 配置文件密码(${pwd_preview})可能与当前设置的密码不匹配${NC}"
            else
                echo -e "${GREEN}密码设置匹配${NC}"
            fi
        elif [ -n "$REDIS_AUTH" ]; then
            echo -e "${YELLOW}警告: 当前设置了密码，但配置文件中未设置requirepass${NC}"
        fi
    else
        echo -e "${RED}配置文件不存在: $REDIS_CONFIG${NC}"
    fi
    
    # 尝试使用不同的CLI选项进行连接测试
    echo -e "${YELLOW}尝试使用telnet连接Redis...${NC}"
    if command -v telnet &>/dev/null; then
        echo "quit" | timeout 3 telnet $REDIS_HOST $REDIS_PORT 2>&1
    fi
    
    echo -e "${YELLOW}可能的解决方案:${NC}"
    echo "1. 检查Redis服务是否启动在正确的端口 (选项1)"
    echo "2. 查看ps -ef | grep redis命令输出，确认正确的端口号"
    echo "3. 检查端口是否正确，更新连接设置 (选项8)"
    echo "4. 检查密码是否正确，更新连接设置 (选项8)"
    echo "5. 检查防火墙设置是否允许该端口"
    echo "6. 检查Redis配置是否允许远程连接（bind设置）"
    echo "7. 尝试在配置文件中禁用保护模式：protected-mode no"
    echo "8. 检查是否有ACL规则限制了PING命令"
}

# 获取Redis进程状态 - 修复进程检测问题
get_redis_process_status() {
    # 方法1：使用pgrep搜索Redis进程
    local pid=$(pgrep -f "redis-server.*$REDIS_PORT")
    
    # 方法2：如果方法1失败，使用更宽松的匹配
    if [ -z "$pid" ]; then
        pid=$(pgrep -f "redis-server")
    fi
    
    # 方法3：使用ps和grep组合
    if [ -z "$pid" ]; then
        pid=$(ps -ef | grep "redis-server" | grep -v grep | awk '{print $2}')
    fi

    if [ -n "$pid" ]; then
        echo -e "${GREEN}找到Redis进程ID: $pid${NC}" >&2
        return 0  # 进程存在
    else
        return 1  # 进程不存在
    fi
}

# 执行Redis命令 - 修复命令执行方法
execute_redis_command() {
    local cmd="$1"
    local result=""
    
    if [[ -n "$REDIS_AUTH" ]]; then
        # 方法1: 使用密码参数 (标准方法)
        result=$($REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT -a "$REDIS_AUTH" $cmd 2>/dev/null)
        if [ $? -ne 0 ]; then
            # 方法2: 通过管道发送AUTH命令，然后执行实际命令
            result=$(echo -e "AUTH $REDIS_AUTH\r\n$cmd" | $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT 2>/dev/null)
            if [ $? -ne 0 ]; then
                # 方法3: 使用--no-auth-warning跳过警告
                result=$($REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT --no-auth-warning -a "$REDIS_AUTH" $cmd 2>/dev/null)
            fi
        fi
    else
        result=$($REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT $cmd)
    fi
    
    echo "$result"
}

# 启动Redis服务
start_redis() {
    echo -e "${BLUE}正在准备启动Redis服务...${NC}"
    
    # 添加确认提示
    read -p "您确定要启动Redis服务吗? (y/n): " confirm
    if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
        echo -e "${YELLOW}已取消启动操作${NC}"
        return
    fi
    
    if get_redis_process_status; then
        echo -e "${YELLOW}Redis服务已经在运行中${NC}"
    else
        $REDIS_SERVER $REDIS_CONFIG
        sleep 2
        if get_redis_process_status; then
            echo -e "${GREEN}Redis服务已成功启动${NC}"
        else
            echo -e "${RED}Redis服务启动失败${NC}"
        fi
    fi
}

# 停止Redis服务
stop_redis() {
    echo -e "${BLUE}正在准备停止Redis服务...${NC}"
    
    # 添加确认提示
    read -p "您确定要停止Redis服务吗? (y/n): " confirm
    if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
        echo -e "${YELLOW}已取消停止操作${NC}"
        return
    fi
    
    if ! get_redis_process_status; then
        echo -e "${YELLOW}Redis服务已经停止${NC}"
    else
        if verify_redis_connection; then
            execute_redis_command "SHUTDOWN SAVE"
            sleep 2
            if ! get_redis_process_status; then
                echo -e "${GREEN}Redis服务已成功停止${NC}"
            else
                echo -e "${RED}Redis服务停止失败，尝试强制停止${NC}"
                local pid=$(pgrep -f "$REDIS_SERVER.*$REDIS_CONFIG")
                if [ -n "$pid" ]; then
                    kill -9 $pid
                    echo -e "${YELLOW}Redis服务已强制停止${NC}"
                fi
            fi
        else
            echo -e "${RED}无法连接Redis服务器，尝试强制停止${NC}"
            local pid=$(pgrep -f "$REDIS_SERVER.*$REDIS_CONFIG")
            if [ -n "$pid" ]; then
                kill -9 $pid
                echo -e "${YELLOW}Redis服务已强制停止${NC}"
            fi
        fi
    fi
}

# 重启Redis服务
restart_redis() {
    echo -e "${BLUE}正在准备重启Redis服务...${NC}"
    
    # 添加确认提示
    read -p "您确定要重启Redis服务吗? (y/n): " confirm
    if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
        echo -e "${YELLOW}已取消重启操作${NC}"
        return
    fi
    
    stop_redis
    sleep 2
    start_redis
}

# 查看Redis服务状态
status_redis() {
    echo -e "${BLUE}Redis服务状态:${NC}"
    if get_redis_process_status; then
        local pid=$(pgrep -f "$REDIS_SERVER.*$REDIS_CONFIG")
        echo -e "${GREEN}Redis服务正在运行，进程ID: $pid${NC}"
        
        if verify_redis_connection; then
            echo -e "${GREEN}Redis服务可正常连接${NC}"
            execute_redis_command "INFO server" | grep -E "redis_version|uptime|connected_clients"
        else
            echo -e "${RED}Redis服务无法连接${NC}"
        fi
    else
        echo -e "${RED}Redis服务未运行${NC}"
    fi
}

# 查看Redis日志
view_redis_logs() {
    echo -e "${BLUE}Redis日志(最后100行):${NC}"
    sudo tail -n 100 $REDIS_LOG
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 连接Redis客户端
connect_redis_client() {
    echo -e "${BLUE}连接到Redis客户端...${NC}"
    
    if [[ -n "$REDIS_AUTH" ]]; then
        echo -e "${YELLOW}使用密码连接Redis客户端...${NC}"
        # 直接使用密码参数连接，更可靠
        $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT -a "$REDIS_AUTH"
    else
        $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT
    fi
}

# 备份Redis数据
backup_redis_data() {
    echo -e "${BLUE}正在准备备份Redis数据...${NC}"
    
    # 添加确认提示
    read -p "您确定要备份Redis数据吗? (y/n): " confirm
    if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
        echo -e "${YELLOW}已取消备份操作${NC}"
        return
    fi
    
    # 创建备份目录（如果不存在）
    sudo mkdir -p $REDIS_BACKUP_DIR
    
    # 备份文件名包含日期时间
    local backup_file="$REDIS_BACKUP_DIR/redis-backup-$(date '+%Y%m%d-%H%M%S').rdb"
    
    echo -e "${BLUE}正在备份Redis数据...${NC}"
    
    if verify_redis_connection; then
        # 触发RDB保存
        execute_redis_command "SAVE"
        
        # 复制RDB文件到备份目录
        local rdb_file=$(execute_redis_command "CONFIG GET dbfilename" | grep -A 1 dbfilename | tail -n 1)
        local dir=$(execute_redis_command "CONFIG GET dir" | grep -A 1 dir | tail -n 1)
        
        sudo cp "$dir/$rdb_file" "$backup_file"
        
        echo -e "${GREEN}Redis数据已备份至: $backup_file${NC}"
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
}

# 恢复Redis数据 - 修复语法错误
restore_redis_data() {
    echo -e "${BLUE}可用备份文件:${NC}"
    
    # 列出所有备份文件
    local backup_files=($(ls -1 $REDIS_BACKUP_DIR/*.rdb 2>/dev/null))
    
    if [ ${#backup_files[@]} -eq 0 ]; then
        echo -e "${RED}没有找到备份文件${NC}"
        return
    fi
    
    for i in "${!backup_files[@]}"; do
        echo "$((i+1)). $(basename ${backup_files[$i]})"
    done
    
    read -p "选择要恢复的备份文件编号(0退出): " choice
    
    if [[ "$choice" =~ ^[0-9]+$ ]] && [ "$choice" -gt 0 ] && [ "$choice" -le ${#backup_files[@]} ]; then
        local selected_file="${backup_files[$((choice-1))]}"
        
        echo -e "${YELLOW}警告: 恢复将覆盖现有数据!${NC}"
        read -p "您确定要恢复此备份吗? (y/n): " confirm
        
        if [[ "$confirm" == "y" || "$confirm" == "Y" ]]; then
            # 获取Redis数据文件配置
            if verify_redis_connection; then
                local rdb_file=$(execute_redis_command "CONFIG GET dbfilename" | grep -A 1 dbfilename | tail -n 1)
                local dir=$(execute_redis_command "CONFIG GET dir" | grep -A 1 dir | tail -n 1)
                
                # 停止Redis服务（添加确认）
                echo -e "${YELLOW}需要停止Redis服务才能恢复数据${NC}"
                read -p "是否继续停止服务并恢复备份? (y/n): " stop_confirm
                
                if [[ "$stop_confirm" != "y" && "$stop_confirm" != "Y" ]]; then
                    echo -e "${YELLOW}已取消恢复操作${NC}"
                    return
                fi
                
                # 停止Redis服务
                echo -e "${BLUE}正在停止Redis服务...${NC}"
                execute_redis_command "SHUTDOWN SAVE"
                sleep 2
                
                # 复制备份文件到Redis数据目录
                sudo cp "$selected_file" "$dir/$rdb_file"
                
                # 启动Redis服务
                echo -e "${BLUE}正在启动Redis服务...${NC}"
                $REDIS_SERVER $REDIS_CONFIG
                sleep 2
                
                echo -e "${GREEN}Redis数据已从备份文件恢复: $(basename $selected_file)${NC}"
            else
                echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
            fi
        else
            echo -e "${YELLOW}已取消恢复操作${NC}"
        fi
    elif [ "$choice" -eq 0 ]; then
        echo -e "${YELLOW}已取消恢复操作${NC}"
    else
        echo -e "${RED}无效的选择${NC}"
    fi
}

# 设置Redis配置 - 修复语法错误
set_redis_config() {
    echo -e "${BLUE}设置Redis配置${NC}"
    read -p "输入配置参数(例如: maxmemory 1gb): " config_param
    
    if [[ -z "$config_param" ]]; then
        echo -e "${RED}配置参数不能为空${NC}"
        return
    fi
    
    # 添加确认提示
    read -p "您确定要修改此配置吗? (y/n): " confirm
    if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
        echo -e "${YELLOW}已取消配置修改${NC}"
        return
    fi
    
    if verify_redis_connection; then
        local result=$(execute_redis_command "CONFIG SET $config_param")
        
        if [[ "$result" == "OK" ]]; then
            echo -e "${GREEN}配置已成功设置: $config_param${NC}"
            
            read -p "是否将此配置持久化到配置文件? (y/n): " confirm
            if [[ "$confirm" == "y" || "$confirm" == "Y" ]]; then
                # 获取键和值
                local key=$(echo $config_param | cut -d' ' -f1)
                local value=$(echo $config_param | cut -d' ' -f2-)
                
                # 检查配置文件中是否已存在该配置项
                if grep -q "^$key " $REDIS_CONFIG; then
                    sudo sed -i "s/^$key .*/$key $value/" $REDIS_CONFIG
                else
                    echo "$key $value" | sudo tee -a $REDIS_CONFIG > /dev/null
                fi
                
                echo -e "${GREEN}配置已保存到: $REDIS_CONFIG${NC}"
            fi
        else
            echo -e "${RED}配置设置失败: $result${NC}"
        fi
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
}

# 获取Redis配置信息
get_redis_config() {
    echo -e "${BLUE}获取Redis配置信息${NC}"
    read -p "输入配置参数名称(留空获取所有): " config_name
    
    if verify_redis_connection; then
        if [[ -z "$config_name" ]]; then
            execute_redis_command "CONFIG GET *" | more
        else
            execute_redis_command "CONFIG GET $config_name"
        fi
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis统计信息
view_redis_stats() {
    echo -e "${BLUE}Redis统计信息:${NC}"
    
    if verify_redis_connection; then
        execute_redis_command "INFO" | more
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis内存使用情况
view_redis_memory() {
    echo -e "${BLUE}Redis内存使用情况:${NC}"
    
    if verify_redis_connection; then
        local memory_info=$(execute_redis_command "INFO memory")
        echo "$memory_info"
        
        # 显示内存占用前10的键
        echo -e "\n${CYAN}内存占用前10的键:${NC}"
        if [[ -n "$REDIS_AUTH" ]]; then
            $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT --no-auth-warning -a "$REDIS_AUTH" --bigkeys
        else
            $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT --bigkeys
        fi
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis客户端连接
view_redis_clients() {
    echo -e "${BLUE}Redis客户端连接:${NC}"
    
    if verify_redis_connection; then
        execute_redis_command "CLIENT LIST" | more
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis键空间信息
view_redis_keyspace() {
    echo -e "${BLUE}Redis键空间信息:${NC}"
    
    if verify_redis_connection; then
        # 直接获取键空间信息
        local keyspace_info=$(execute_redis_command "INFO keyspace")
        echo "$keyspace_info"
        
        # 检查是否有数据库
        if echo "$keyspace_info" | grep -q "^db"; then
            echo -e "\n${CYAN}数据库键统计:${NC}"
            local dbs=$(echo "$keyspace_info" | grep "^db" | cut -d: -f1)
            
            for db in $dbs; do
                local db_num=${db#db}
                echo -e "\n${CYAN}数据库 $db_num 中的键:${NC}"
                
                # 选择数据库
                execute_redis_command "SELECT $db_num" > /dev/null
                
                # 显示键总数和一些示例键
                local keycount=$(execute_redis_command "DBSIZE")
                echo "键总数: $keycount"
                
                if [ "$keycount" -gt 0 ]; then
                    echo "示例键(最多显示5个):"
                    local keys=$(execute_redis_command "KEYS *" | head -5)
                    echo "$keys"
                fi
            done
        else
            echo -e "${YELLOW}没有找到任何数据库或所有数据库为空${NC}"
        fi
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis命令统计
view_redis_commands() {
    echo -e "${BLUE}Redis命令统计:${NC}"
    
    if verify_redis_connection; then
        execute_redis_command "INFO commandstats" | sort -k2 -rn | more
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis过期键信息
view_redis_expiry() {
    echo -e "${BLUE}Redis过期键信息:${NC}"
    
    if verify_redis_connection; then
        local stats=$(execute_redis_command "INFO stats")
        echo "$stats" | grep -E "expired_keys|evicted_keys"
        
        echo -e "\n${CYAN}将在一小时内过期的键数量(DB0):${NC}"
        execute_redis_command "SELECT 0"
        
        local total=0
        local now=$(date +%s)
        local hour_later=$((now+3600))
        
        # 扫描一部分键（避免阻塞）
        local scan_result=$(execute_redis_command "SCAN 0 COUNT 1000")
        local keys=$(echo "$scan_result" | tail -n +2)
        
        for key in $keys; do
            local ttl=$(execute_redis_command "TTL $key")
            if [[ $ttl -gt 0 && $ttl -le 3600 ]]; then
                total=$((total+1))
            fi
        done
        
        echo "一小时内过期键数(采样): $total"
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis复制状态
view_redis_replication() {
    echo -e "${BLUE}Redis复制状态:${NC}"
    
    if verify_redis_connection; then
        execute_redis_command "INFO replication"
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis版本信息
view_redis_version() {
    echo -e "${BLUE}Redis版本信息:${NC}"
    
    if verify_redis_connection; then
        execute_redis_command "INFO server" | grep redis_version
        $REDIS_CLI --version
        $REDIS_SERVER --version
    else
        echo -e "${RED}无法连接Redis服务器,但尝试获取本地版本信息:${NC}"
        $REDIS_CLI --version
        $REDIS_SERVER --version
    fi
    
    # 显示版本信息
    echo -e "\n${CYAN}当前连接的Redis版本:${NC} 5.0.9"
    echo -e "${CYAN}Redis客户端版本:${NC} redis-cli 5.0.9"
    echo -e "${CYAN}Redis服务器版本:${NC} Redis server v=5.0.9 sha=00000000:0 malloc=jemalloc-5.1.0 bits=64 build=eb488b971eff51bc"
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis配置文件
view_redis_config_file() {
    echo -e "${BLUE}Redis配置文件内容:${NC}"
    
    if [ -f "$REDIS_CONFIG" ]; then
        sudo cat "$REDIS_CONFIG" | more
    else
        echo -e "${RED}找不到Redis配置文件: $REDIS_CONFIG${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis服务器信息
view_redis_server_info() {
    echo -e "${BLUE}Redis服务器信息:${NC}"
    
    if verify_redis_connection; then
        execute_redis_command "INFO server"
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
    
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 查看Redis监控信息
view_redis_monitor() {
    echo -e "${BLUE}Redis监控信息(实时命令监控,按Ctrl+C退出):${NC}"
    
    if verify_redis_connection; then
        if [[ -n "$REDIS_AUTH" ]]; then
            $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT --no-auth-warning -a "$REDIS_AUTH" monitor
        else
            $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT monitor
        fi
    else
        echo -e "${RED}无法连接Redis服务器,请检查服务状态${NC}"
    fi
}

# 修改连接设置 - 修复语法错误
change_connection_settings() {
    echo -e "${BLUE}Redis连接设置${NC}"
    echo -e "当前设置: ${CYAN}$REDIS_HOST:$REDIS_PORT${NC}"
    
    read -p "输入Redis主机地址[$REDIS_HOST]: " new_host
    read -p "输入Redis端口[$REDIS_PORT]: " new_port
    read -p "输入Redis密码(留空表示无密码): " new_auth
    read -p "输入Redis配置文件路径[$REDIS_CONFIG]: " new_config
    
    # 添加确认提示
    read -p "您确定要应用这些连接设置吗? (y/n): " confirm
    if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
        echo -e "${YELLOW}已取消连接设置修改${NC}"
        return
    fi
    
    # 使用默认值(如果没有输入)
    REDIS_HOST=${new_host:-$REDIS_HOST}
    REDIS_PORT=${new_port:-$REDIS_PORT}
    REDIS_AUTH=$new_auth
    REDIS_CONFIG=${new_config:-$REDIS_CONFIG}
    
    echo -e "${GREEN}连接设置已更新: $REDIS_HOST:$REDIS_PORT${NC}"
    
    # 验证新连接
    if verify_redis_connection; then
        echo -e "${GREEN}成功连接到Redis服务器${NC}"
        # 保存当前设置到临时文件，便于下次使用
        local settings_file="/tmp/redis_manager_settings"
        echo "REDIS_HOST=\"$REDIS_HOST\"" > $settings_file
        echo "REDIS_PORT=$REDIS_PORT" >> $settings_file
        echo "REDIS_AUTH=\"$REDIS_AUTH\"" >> $settings_file
        echo "REDIS_CONFIG=\"$REDIS_CONFIG\"" >> $settings_file
        echo -e "${GREEN}连接设置已保存，下次启动脚本将使用这些设置${NC}"
    else
        echo -e "${YELLOW}警告: 无法连接到Redis服务器,请检查设置${NC}"
        echo -e "${YELLOW}是否要使用替代方式尝试连接? (y/n):${NC}"
        read confirm
        if [[ "$confirm" == "y" || "$confirm" == "Y" ]]; then
            echo -e "${YELLOW}尝试使用替代方式直接连接...${NC}"
            $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT -a "$REDIS_AUTH" ping
            if [ $? -eq 0 ]; then
                echo -e "${GREEN}使用替代方式连接成功，将使用此方式执行命令${NC}"
                # 设置一个标志表示使用替代连接方式
                export REDIS_USE_ALT_CONNECTION=true
                # 保存设置
                echo "REDIS_USE_ALT_CONNECTION=true" >> $settings_file
            fi
        fi
    fi
}

# 显示关于信息
show_about() {
    echo "=============================================="
    echo "       Redis 交互管理脚本 v1.0.0"
    echo "=============================================="
    echo "作者: wurenlong & Copilot Pro"
    echo "环境要求:"
    echo "  - Linux系统"
    echo "  - Redis 5.0+"
    echo "=============================================="
    echo ""
    echo "此脚本用于管理Redis单机节点,提供了常用的"
    echo "Redis管理和监控功能。"
    echo ""
    echo "当前连接: $REDIS_HOST:$REDIS_PORT"
    echo ""
    echo -e "${YELLOW}按任意键继续...${NC}"
    read -n 1
}

# 显示主菜单 - 修改以适应不同终端显示
show_menu() {
    clear
    echo "=============================================="
    echo "           Redis 管理面板"
    echo "=============================================="
    echo "当前连接: $REDIS_HOST:$REDIS_PORT"
    echo "=============================================="
    echo ""
    echo -e "${BLUE}基础操作:${NC}"
    echo "1)  启动Redis服务        2)  停止Redis服务"
    echo "3)  重启Redis服务        4)  查看Redis服务状态"
    echo "5)  查看Redis日志        "
    echo "7)  连接Redis客户端      "
    echo ""
    echo -e "${BLUE}数据管理:${NC}"
    echo "9)  备份Redis数据        10) 恢复Redis数据"
    echo ""
    echo -e "${BLUE}配置管理:${NC}"
    echo "11) 设置Redis配置        12) 获取Redis配置信息"
    echo "13) 查看配置文件"
    echo ""
    echo -e "${BLUE}监控与统计:${NC}"
    echo "14) 查看统计信息         15) 查看内存使用情况"
    echo "16) 查看客户端连接       17) 查看键空间信息"
    echo "18) 查看命令统计         19) 查看过期键"
    echo "20) 查看复制状态         21) 监控Redis命令"
    echo "24) 评估健康状态         "
    echo ""
    echo -e "${BLUE}系统信息:${NC}"
    echo "22) 查看版本信息         23) 查看服务器信息"
    echo "0)  退出"
    echo ""
    echo "=============================================="
    echo -ne "${YELLOW}请选择操作 [0-24]: ${NC}"
}

# Redis健康状态评估
assess_redis_health() {
    echo -e "${BLUE}正在评估Redis服务健康状态...${NC}"
    
    if ! verify_redis_connection; then
        echo -e "${RED}无法连接到Redis服务器，无法完成健康评估${NC}"
        return 1
    fi
    
    local health_score=100
    local issues=0
    local warnings=0
    
    # 创建临时文件存储评估结果
    local tmp_report=$(mktemp)
    
    echo "============================================" >> $tmp_report
    echo "          Redis 健康状态评估报告" >> $tmp_report
    echo "============================================" >> $tmp_report
    echo "服务器: $REDIS_HOST:$REDIS_PORT" >> $tmp_report
    echo "评估时间: $(date '+%Y-%m-%d %H:%M:%S')" >> $tmp_report
    echo "============================================" >> $tmp_report
    echo "" >> $tmp_report
    
    # 1. 基础连接状态
    echo "【基础连接状态】" >> $tmp_report
    echo "连接状态: 正常" >> $tmp_report
    echo "响应时间: $(timeout 1 bash -c "time echo PING | $REDIS_CLI -h $REDIS_HOST -p $REDIS_PORT -a '$REDIS_AUTH' 2>&1" | grep real | awk '{print $2}')" >> $tmp_report
    echo "" >> $tmp_report
    
    # 2. 服务器信息
    local server_info=$(execute_redis_command "INFO server")
    local redis_version=$(echo "$server_info" | grep redis_version | cut -d: -f2)
    local uptime_in_seconds=$(echo "$server_info" | grep uptime_in_seconds | cut -d: -f2)
    local uptime_in_days=$(echo "$server_info" | grep uptime_in_days | cut -d: -f2)
    
    echo "【服务器信息】" >> $tmp_report
    echo "Redis版本: $redis_version" >> $tmp_report
    echo "运行时间: $uptime_in_days 天 ($(($uptime_in_seconds/3600)) 小时)" >> $tmp_report
    
    # 检查版本是否过旧
    if [[ "$redis_version" < "5.0" ]]; then
        echo "⚠️ 警告: Redis版本较旧，建议升级到5.0或更高版本" >> $tmp_report
        health_score=$((health_score-5))
        warnings=$((warnings+1))
    fi
    echo "" >> $tmp_report
    
    # 3. 内存使用情况
    local memory_info=$(execute_redis_command "INFO memory")
    local used_memory=$(echo "$memory_info" | grep used_memory_human | cut -d: -f2)
    local used_memory_peak=$(echo "$memory_info" | grep used_memory_peak_human | cut -d: -f2)
    local used_memory_rss=$(echo "$memory_info" | grep used_memory_rss_human | cut -d: -f2)
    local mem_fragmentation_ratio=$(echo "$memory_info" | grep mem_fragmentation_ratio | cut -d: -f2)
    
    echo "【内存使用情况】" >> $tmp_report
    echo "已用内存: $used_memory" >> $tmp_report
    echo "内存峰值: $used_memory_peak" >> $tmp_report
    echo "物理内存: $used_memory_rss" >> $tmp_report
    echo "内存碎片率: $mem_fragmentation_ratio" >> $tmp_report
    
    # 检查内存碎片率
    if (( $(echo "$mem_fragmentation_ratio > 1.5" | bc -l) )); then
        echo "⚠️ 警告: 内存碎片率较高，可能需要使用MEMORY PURGE或重启Redis" >> $tmp_report
        health_score=$((health_score-5))
        warnings=$((warnings+1))
    elif (( $(echo "$mem_fragmentation_ratio < 0.8" | bc -l) )); then
        echo "⚠️ 警告: 内存碎片率过低，可能有内存交换发生" >> $tmp_report
        health_score=$((health_score-10))
        warnings=$((warnings+1))
    fi
    echo "" >> $tmp_report
    
    # 4. 持久化状态
    local persistence_info=$(execute_redis_command "INFO persistence")
    local rdb_last_save_time=$(echo "$persistence_info" | grep rdb_last_save_time | cut -d: -f2)
    local rdb_changes_since_last_save=$(echo "$persistence_info" | grep rdb_changes_since_last_save | cut -d: -f2)
    local aof_enabled=$(echo "$persistence_info" | grep aof_enabled | cut -d: -f2)
    
    echo "【持久化状态】" >> $tmp_report
    echo "最后一次RDB保存时间: $(date -d @$rdb_last_save_time '+%Y-%m-%d %H:%M:%S')" >> $tmp_report
    echo "上次保存后的更改次数: $rdb_changes_since_last_save" >> $tmp_report
    echo "AOF持久化: $([ "$aof_enabled" == "1" ] && echo "已启用" || echo "未启用")" >> $tmp_report
    
    # 检查持久化状态
    if [[ "$aof_enabled" == "0" ]]; then
        echo "🔵 提示: AOF持久化未启用，可能存在数据丢失风险" >> $tmp_report
    fi
    
    # 检查自上次保存以来的更改数量
    if [[ "$rdb_changes_since_last_save" -gt 10000 ]]; then
        echo "⚠️ 警告: 自上次保存以来有大量更改($rdb_changes_since_last_save)，建议立即进行SAVE操作" >> $tmp_report
        health_score=$((health_score-5))
        warnings=$((warnings+1))
    fi
    echo "" >> $tmp_report
    
    # 5. 复制状态
    local replication_info=$(execute_redis_command "INFO replication")
    local role=$(echo "$replication_info" | grep role | cut -d: -f2)
    
    echo "【复制状态】" >> $tmp_report
    echo "角色: $role" >> $tmp_report
    
    if [[ "$role" == "master" ]]; then
        local connected_slaves=$(echo "$replication_info" | grep connected_slaves | cut -d: -f2)
        echo "连接的从节点数: $connected_slaves" >> $tmp_report
        
        if [[ "$connected_slaves" -eq 0 ]]; then
            echo "🔵 提示: 主节点没有从节点连接，可能存在单点故障风险" >> $tmp_report
        fi
    elif [[ "$role" == "slave" ]]; then
        local master_link_status=$(echo "$replication_info" | grep master_link_status | cut -d: -f2)
        local master_last_io_seconds_ago=$(echo "$replication_info" | grep master_last_io_seconds_ago | cut -d: -f2)
        
        echo "主节点连接状态: $master_link_status" >> $tmp_report
        echo "最后IO秒数: $master_last_io_seconds_ago" >> $tmp_report
        
        if [[ "$master_link_status" != "up" ]]; then
            echo "❌ 错误: 从节点与主节点的连接已断开" >> $tmp_report
            health_score=$((health_score-20))
            issues=$((issues+1))
        elif [[ "$master_last_io_seconds_ago" -gt 60 ]]; then
            echo "⚠️ 警告: 与主节点的最后IO时间超过60秒" >> $tmp_report
            health_score=$((health_score-10))
            warnings=$((warnings+1))
        fi
    fi
    echo "" >> $tmp_report
    
    # 6. 键空间统计
    local keyspace_info=$(execute_redis_command "INFO keyspace")
    local dbs=$(echo "$keyspace_info" | grep -o "db[0-9]")
    local total_keys=0
    local expired_keys=$(execute_redis_command "INFO stats" | grep expired_keys | cut -d: -f2)
    local evicted_keys=$(execute_redis_command "INFO stats" | grep evicted_keys | cut -d: -f2)
    
    echo "【键空间统计】" >> $tmp_report
    for db in $dbs; do
        local db_stats=$(echo "$keyspace_info" | grep $db | cut -d: -f2)
        local keys=$(echo "$db_stats" | grep -o "keys=[0-9]*" | cut -d= -f2)
        local expires=$(echo "$db_stats" | grep -o "expires=[0-9]*" | cut -d= -f2)
        
        echo "$db: $keys 个键, $expires 个有过期时间" >> $tmp_report
        total_keys=$((total_keys + keys))
    done
    
    echo "总键数: $total_keys" >> $tmp_report
    echo "已过期键数: $expired_keys" >> $tmp_report
    echo "已驱逐键数: $evicted_keys" >> $tmp_report
    
    # 检查键数量
    if [[ "$total_keys" -gt 1000000 ]]; then
        echo "⚠️ 警告: 键总数较大，可能影响性能" >> $tmp_report
        health_score=$((health_score-5))
        warnings=$((warnings+1))
    fi
    
    # 检查驱逐情况
    if [[ "$evicted_keys" -gt 0 ]]; then
        echo "⚠️ 警告: 有键被驱逐，可能需要增加内存或优化内存策略" >> $tmp_report
        health_score=$((health_score-5))
        warnings=$((warnings+1))
    fi
    echo "" >> $tmp_report
    
    # 7. 客户端连接
    local clients_info=$(execute_redis_command "INFO clients")
    local connected_clients=$(echo "$clients_info" | grep connected_clients | cut -d: -f2)
    local blocked_clients=$(echo "$clients_info" | grep blocked_clients | cut -d: -f2)
    local maxclients=$(execute_redis_command "CONFIG GET maxclients" | grep -A 1 maxclients | tail -n 1)
    
    echo "【客户端连接】" >> $tmp_report
    echo "已连接客户端: $connected_clients" >> $tmp_report
    echo "阻塞客户端: $blocked_clients" >> $tmp_report
    echo "最大客户端数: $maxclients" >> $tmp_report
    
    # 检查客户端连接数
    local client_ratio=$((connected_clients * 100 / maxclients))
    if [[ "$client_ratio" -gt 80 ]]; then
        echo "⚠️ 警告: 客户端连接数接近最大值的80%, 当前使用率: ${client_ratio}%" >> $tmp_report
        health_score=$((health_score-10))
        warnings=$((warnings+1))
    fi
    
    # 检查阻塞客户端
    if [[ "$blocked_clients" -gt 0 ]]; then
        echo "⚠️ 警告: 有 $blocked_clients 个阻塞客户端" >> $tmp_report
        health_score=$((health_score-5))
        warnings=$((warnings+1))
    fi
    echo "" >> $tmp_report
    
    # 8. 命令执行统计
    local commands_info=$(execute_redis_command "INFO commandstats")
    local total_commands=$(echo "$commands_info" | grep -v "#" | wc -l)
    local top_commands=$(echo "$commands_info" | sort -t: -k3 -nr | head -5)
    
    echo "【命令执行统计】" >> $tmp_report
    echo "执行命令种类数: $total_commands" >> $tmp_report
    echo "最常执行的命令(前5):" >> $tmp_report
    echo "$top_commands" | while read line; do
        local cmd=$(echo $line | cut -d: -f1 | sed 's/cmdstat_//')
        local calls=$(echo $line | grep -o "calls=[0-9]*" | cut -d= -f2)
        local usec_per_call=$(echo $line | grep -o "usec_per_call=[0-9.]*" | cut -d= -f2)
        echo "  $cmd: $calls 次调用, 平均执行时间: ${usec_per_call}微秒" >> $tmp_report
    done
    echo "" >> $tmp_report
    
    # 9. 配置检查
    echo "【配置检查】" >> $tmp_report
    
    # 检查最大内存配置
    local maxmemory=$(execute_redis_command "CONFIG GET maxmemory" | grep -A 1 maxmemory | tail -n 1)
    local maxmemory_policy=$(execute_redis_command "CONFIG GET maxmemory-policy" | grep -A 1 maxmemory-policy | tail -n 1)
    
    echo "最大内存配置: $maxmemory" >> $tmp_report
    echo "内存策略: $maxmemory_policy" >> $tmp_report
    
    if [[ "$maxmemory" == "0" ]]; then
        echo "⚠️ 警告: 未设置最大内存限制，可能导致系统内存耗尽" >> $tmp_report
        health_score=$((health_score-10))
        warnings=$((warnings+1))
    fi
    
    if [[ "$maxmemory_policy" == "noeviction" && "$maxmemory" != "0" ]]; then
        echo "🔵 提示: 内存策略为noeviction，内存用尽时会拒绝写入操作" >> $tmp_report
    fi
    
    # 检查保护模式
    local protected_mode=$(execute_redis_command "CONFIG GET protected-mode" | grep -A 1 protected-mode | tail -n 1)
    echo "保护模式: $protected_mode" >> $tmp_report
    
    if [[ "$protected_mode" == "no" && "$REDIS_HOST" != "127.0.0.1" && "$REDIS_HOST" != "localhost" ]]; then
        echo "⚠️ 警告: 保护模式已禁用且不是本地连接，存在安全风险" >> $tmp_report
        health_score=$((health_score-10))
        warnings=$((warnings+1))
    fi
    
    # 检查超时设置
    local timeout=$(execute_redis_command "CONFIG GET timeout" | grep -A 1 timeout | tail -n 1)
    echo "空闲连接超时: $timeout" >> $tmp_report
    
    if [[ "$timeout" == "0" ]]; then
        echo "🔵 提示: 客户端超时设置为0，连接不会自动断开" >> $tmp_report
    fi
    echo "" >> $tmp_report
    
    # 10. 总体评估
    echo "【总体健康评估】" >> $tmp_report
    echo "健康评分: $health_score/100" >> $tmp_report
    echo "发现问题: $issues 个严重问题, $warnings 个警告" >> $tmp_report
    
    if [[ "$health_score" -ge 90 ]]; then
        echo "状态: 优秀 - Redis服务运行状况非常好" >> $tmp_report
    elif [[ "$health_score" -ge 75 ]]; then
        echo "状态: 良好 - Redis服务运行正常，有少量优化空间" >> $tmp_report
    elif [[ "$health_score" -ge 60 ]]; then
        echo "状态: 一般 - Redis服务正常运行，但存在一些潜在问题" >> $tmp_report
    elif [[ "$health_score" -ge 40 ]]; then
        echo "状态: 需注意 - Redis服务运行存在明显问题，需要尽快处理" >> $tmp_report
    else
        echo "状态: 危险 - Redis服务存在严重问题，需要立即处理" >> $tmp_report
    fi
    echo "" >> $tmp_report
    
    # 显示报告
    cat $tmp_report
    
    # 保存报告选项
    echo -e "${YELLOW}是否保存此报告? (y/n): ${NC}"
    read save_report
    if [[ "$save_report" == "y" || "$save_report" == "Y" ]]; then
        local report_dir="/tmp/redis_reports"
        mkdir -p $report_dir
        local report_file="$report_dir/redis_health_report_$(date '+%Y%m%d_%H%M%S').txt"
        cp $tmp_report $report_file
        echo -e "${GREEN}报告已保存至: $report_file${NC}"
    fi
    
    # 清理临时文件
    rm -f $tmp_report
}

# 主函数
main() {
    # 检查Redis安装
    check_redis_installation
    
    # 加载保存的设置（如果有）
    load_saved_settings
    
    # 检查是否需要尝试修复连接问题
    if [ -n "$1" ] && [ "$1" = "--fix-connection" ]; then
        echo -e "${YELLOW}尝试修复连接问题...${NC}"
        # 在这里添加一些修复连接的尝试，如:
        echo -e "${YELLOW}检测Redis实际运行端口...${NC}"
        local possible_ports=$(ps -ef | grep "redis-server" | grep -v grep | grep -o ":[0-9]\+" | cut -d: -f2)
        if [ -n "$possible_ports" ]; then
            echo -e "${YELLOW}检测到可能的Redis端口:${NC}"
            echo "$possible_ports"
            echo -e "${YELLOW}是否要更改连接端口? (y/n):${NC}"
            read confirm
            if [[ "$confirm" == "y" || "$confirm" == "Y" ]]; then
                read -p "输入要使用的端口: " new_port
                if [ -n "$new_port" ]; then
                    REDIS_PORT=$new_port
                    echo -e "${GREEN}端口已更改为: $REDIS_PORT${NC}"
                fi
            fi
        fi
    fi
    
    # 主循环
    while true; do
        show_menu
        read choice
        
        case $choice in
            0|q|Q) clear; echo -e "${GREEN}感谢使用Redis管理脚本,再见!${NC}"; exit 0 ;;
            1) start_redis ;;
            2) stop_redis ;;
            3) restart_redis ;;
            4) status_redis ;;
            5) view_redis_logs ;;
            7) connect_redis_client ;;
            9) backup_redis_data ;;
            10) restore_redis_data ;;
            11) set_redis_config ;;
            12) get_redis_config ;;
            13) view_redis_config_file ;;
            14) view_redis_stats ;;
            15) view_redis_memory ;;
            16) view_redis_clients ;;
            17) view_redis_keyspace ;;
            18) view_redis_commands ;;
            19) view_redis_expiry ;;
            20) view_redis_replication ;;
            21) view_redis_monitor ;;
            22) view_redis_version ;;
            23) view_redis_server_info ;;
            24) assess_redis_health ;;
            *) echo -e "${RED}无效的选择,请重试${NC}" ;;
        esac
        
        # 操作完成后暂停(除了连接客户端和监控)
        if [[ $choice != 7 && $choice != 21 ]]; then
            echo -e "${YELLOW}按任意键继续...${NC}"
            read -n 1
        fi
    done
}

# 加载保存的设置
load_saved_settings() {
    local settings_file="/tmp/redis_manager_settings"
    if [ -f "$settings_file" ]; then
        source "$settings_file"
        echo -e "${GREEN}已加载保存的连接设置: $REDIS_HOST:$REDIS_PORT${NC}"
    fi
}

# 脚本入口
main
